﻿using System;
using System.Collections.Generic;
using System.Text;

namespace HolisticWare.VoIP.Getafisk.DLL_02BL_netfx35.any_any_any
{
	[Serializable]
	public
		class 
		ExtensionSIP
		:
		Extension
	{

		# region ---- Property bool Nat --------------------
		private bool _Nat;

		public bool Nat
		{
			get { return _Nat; }
			set
			{
				if (value != _Nat)
				{
					// lock(_Nat) // MultiThread safe
					{
						_Nat = value;
						if (null != NatChanged)
							NatChanged(this, new EventArgs());
					}
				}
			}
		}

		public event EventHandler NatChanged;
		# endregion ---- bool Property.Nat --------------------

		# region ---- Property string DTMFMode --------------------
		private string _DTMFMode;

		public string DTMFMode
		{
			get { return _DTMFMode; }
			set
			{
				if (value != _DTMFMode)
				{
					// lock(_DTMFMode) // MultiThread safe
					{
						_DTMFMode = value;
						if (null != DTMFModeChanged)
							DTMFModeChanged(this, new EventArgs());
					}
				}
			}
		}

		public event EventHandler DTMFModeChanged;
		# endregion ---- string Property.DTMFMode --------------------

		# region ---- Property bool CanReinvite --------------------
		private bool _CanReinvite;

		public bool CanReinvite
		{
			get { return _CanReinvite; }
			set
			{
				if (value != _CanReinvite)
				{
					// lock(_CanReinvite) // MultiThread safe
					{
						_CanReinvite = value;
						if (null != CanReinviteChanged)
							CanReinviteChanged(this, new EventArgs());
					}
				}
			}
		}

		public event EventHandler CanReinviteChanged;
		# endregion ---- bool Property.CanReinvite --------------------

		# region ---- Property string Context --------------------
		private string _Context;

		public string Context
		{
			get { return _Context; }
			set
			{
				if (value != _Context)
				{
					// lock(_Context) // MultiThread safe
					{
						_Context = value;
						if (null != ContextChanged)
							ContextChanged(this, new EventArgs());
					}
				}
			}
		}

		public event EventHandler ContextChanged;
		# endregion ---- string Property.Context --------------------

		# region ---- Property string Host --------------------
		private string _Host;

		public string Host
		{
			get { return _Host; }
			set
			{
				if (value != _Host)
				{
					// lock(_Host) // MultiThread safe
					{
						_Host = value;
						if (null != HostChanged)
							HostChanged(this, new EventArgs());
					}
				}
			}
		}

		public event EventHandler HostChanged;
		# endregion ---- string Property.Host --------------------

		# region ---- Property ClientRelationType Type --------------------
		private ClientRelationType _Type;

		public ClientRelationType Type
		{
			get { return _Type; }
			set
			{
				if (value != _Type)
				{
					// lock(_Type) // MultiThread safe
					{
						_Type = value;
						if (null != TypeChanged)
							TypeChanged(this, new EventArgs());
					}
				}
			}
		}

		public event EventHandler TypeChanged;
		# endregion ---- ClientRelationType Property.Type --------------------

		# region ---- Property int Port --------------------
		private int _Port;

		public int Port
		{
			get { return _Port; }
			set
			{
				if (value != _Port)
				{
					// lock(_Port) // MultiThread safe
					{
						_Port = value;
						if (null != PortChanged)
							PortChanged(this, new EventArgs());
					}
				}
			}
		}

		public event EventHandler PortChanged;
		# endregion ---- int Property.Port --------------------

		# region ---- Property bool Qualify --------------------
		private bool _Qualify;

		public bool Qualify
		{
			get { return _Qualify; }
			set
			{
				if (value != _Qualify)
				{
					// lock(_Qualify) // MultiThread safe
					{
						_Qualify = value;
						if (null != QualifyChanged)
							QualifyChanged(this, new EventArgs());
					}
				}
			}
		}

		public event EventHandler QualifyChanged;
		# endregion ---- bool Property.Qualify --------------------

		# region ---- Property string CallGroup --------------------
		private string _CallGroup;

		public string CallGroup
		{
			get { return _CallGroup; }
			set
			{
				if (value != _CallGroup)
				{
					// lock(_CallGroup) // MultiThread safe
					{
						_CallGroup = value;
						if (null != CallGroupChanged)
							CallGroupChanged(this, new EventArgs());
					}
				}
			}
		}

		public event EventHandler CallGroupChanged;
		# endregion ---- string Property.CallGroup --------------------

		# region ---- Property string PickupGroup --------------------
		private string _PickupGroup;

		public string PickupGroup
		{
			get { return _PickupGroup; }
			set
			{
				if (value != _PickupGroup)
				{
					// lock(_PickupGroup) // MultiThread safe
					{
						_PickupGroup = value;
						if (null != PickupGroupChanged)
							PickupGroupChanged(this, new EventArgs());
					}
				}
			}
		}

		public event EventHandler PickupGroupChanged;
		# endregion ---- string Property.PickupGroup --------------------

		# region ---- Property string Disallow --------------------
		private string _Disallow;

		public string Disallow
		{
			get { return _Disallow; }
			set
			{
				if (value != _Disallow)
				{
					// lock(_Disallow) // MultiThread safe
					{
						_Disallow = value;
						if (null != DisallowChanged)
							DisallowChanged(this, new EventArgs());
					}
				}
			}
		}

		public event EventHandler DisallowChanged;
		# endregion ---- string Property.Disallow --------------------

		# region ---- Property string Allow --------------------
		private string _Allow;

		public string Allow
		{
			get { return _Allow; }
			set
			{
				if (value != _Allow)
				{
					// lock(_Allow) // MultiThread safe
					{
						_Allow = value;
						if (null != AllowChanged)
							AllowChanged(this, new EventArgs());
					}
				}
			}
		}

		public event EventHandler AllowChanged;
		# endregion ---- string Property.Allow --------------------

		# region ---- Property string Dial --------------------
		private string _Dial;

		public string Dial
		{
			get { return _Dial; }
			set
			{
				if (value != _Dial)
				{
					// lock(_Dial) // MultiThread safe
					{
						_Dial = value;
						if (null != DialChanged)
							DialChanged(this, new EventArgs());
					}
				}
			}
		}

		public event EventHandler DialChanged;
		# endregion ---- string Property.Dial --------------------

		# region ---- Property int AccounCode --------------------
		private int _AccounCode;

		public int AccounCode
		{
			get { return _AccounCode; }
			set
			{
				if (value != _AccounCode)
				{
					// lock(_AccounCode) // MultiThread safe
					{
						_AccounCode = value;
						if (null != AccounCodeChanged)
							AccounCodeChanged(this, new EventArgs());
					}
				}
			}
		}

		public event EventHandler AccounCodeChanged;
		# endregion ---- int Property.AccounCode --------------------

		# region ---- Property string MailBox --------------------
		private string _MailBox;

		public string MailBox
		{
			get { return _MailBox; }
			set
			{
				if (value != _MailBox)
				{
					// lock(_MailBox) // MultiThread safe
					{
						_MailBox = value;
						if (null != MailBoxChanged)
							MailBoxChanged(this, new EventArgs());
					}
				}
			}
		}

		public event EventHandler MailBoxChanged;
		# endregion ---- string Property.MailBox --------------------

		# region ---- Property string Deny --------------------
		private string _Deny;

		public string Deny
		{
			get { return _Deny; }
			set
			{
				if (value != _Deny)
				{
					// lock(_Deny) // MultiThread safe
					{
						_Deny = value;
						if (null != DenyChanged)
							DenyChanged(this, new EventArgs());
					}
				}
			}
		}

		public event EventHandler DenyChanged;
		# endregion ---- string Property.Deny --------------------

		# region ---- Property string Permit --------------------
		private string _Permit;

		public string Permit
		{
			get { return _Permit; }
			set
			{
				if (value != _Permit)
				{
					// lock(_Permit) // MultiThread safe
					{
						_Permit = value;
						if (null != PermitChanged)
							PermitChanged(this, new EventArgs());
					}
				}
			}
		}

		public event EventHandler PermitChanged;
		# endregion ---- string Property.Permit --------------------

	
	
	
	
	
	
	
	
	}
}
